/* jshint esversion: 9 */
import Request from "./request-lib";
import {
	apiUrl,
	env,
	apiUrlTest,
	tokenName
} from "@/config";
import {
	getToken,
	removeToken
} from "./auth";

let reqList = [];
const http = new Request();

http.setConfig((config) => {
	config.baseUrl = apiUrl;
	config.header = {
		...config.header,
		[tokenName]: getToken() || ''
	};
	return config;
});

/**
 * 自定义验证器，如果返回true 则进入响应拦截器的响应成功函数(resolve)，否则进入响应拦截器的响应错误函数(reject)
 * @param { Number } statusCode - 请求响应体statusCode（只读）
 * @return { Boolean } 如果为true,则 resolve, 否则 reject
 */
http.validateStatus = (statusCode) => {
	return statusCode === 200;
};

http.interceptor.request((config, cancel) => {
	/* 请求拦截器 */
	// console.log(config.reqType)
	config.header[tokenName] = getToken() || '';

	// if (config.url.indexOf("shangpin") === 0) {
	// 	// 判断接口名，修改请求
	// 	config.jiami = true;
	// 	config.baseUrl = apiUrlTest;
	// }

	// if (config.baseUrl.indexOf("https") === 0) {
	// 	// 判断请求协议
	// }

	// 同步 & 异步
	if (config.sync) {
		if (~reqList.indexOf(config.url)) {
			cancel({
				msg: "请勿重复提交"
			});
			return;
		}
		reqList.push(config.url);
	}

	// 加载动画
	if (config.loading !== false) {
		uni.showLoading({
			title: "请稍后...",
			mask: false,
		});
	}

	config.header = {
		...config.header,
	};

	// token & uuid
	if (!~["UPLOAD"].indexOf(config.method)) { // 普通提交
		if (!config.data[tokenName]) {
			config.data[tokenName] = getToken() || '';
		}
	} else { // 文件提交
		if (config.formData === undefined) config.formData = {};
		if (!config.formData[tokenName]) {
			config.formData[tokenName] = getToken() || '';
		}
	}

	// 开发环境下，如果请求是 post,put,patch,则打印数据体，方便调试
	if (env) {
		const {
			method,
			baseUrl,
			url
		} = config;
		// #ifdef H5
		console.groupCollapsed(
			"%c请求：%c" + baseUrl + url + " " + method,
			"color: red",
			"color:orange"
		);
		console.log("请求数据：", config.data || config.formData);
		// console.log("携带数据：", config.params || '无');
		console.log("全部数据：", config);
		console.groupEnd();
		// #endif
	}

	// 加密
	// console.log('打印加密前数据--->',config.data)
	if (config.jiami) {
		config.data = {
			encrypt: encrypt(JSON.stringify(config.data))
		};
	}
	return config;
});

http.interceptor.response(
	(response) => {
		/* 响应截器 */
		const {
			statusCode,
			config
		} = response;
		const {
			method,
			url,
			baseUrl
		} = config;

		// 去除请求完成的接口（同步机制）
		let idx = reqList.indexOf(config.url);
		if (~idx) {
			reqList.splice(idx, 1);
		}

		if (response.statusCode === 200) {

			let res = response.data;
			// 解密
			if (config.jiami) {
				// console.log('打印解密前--->',res.data)
				res = decrypt(res);
			}

			// 多语言
			// try {
			// 	let lang = uni.getStorageSync("lang");
			// 	let idx = ["zh-CN", "en-US", "zh-TW"].indexOf(lang) || 0;
			// 	res.msg = res.msg.split("|")[idx] || res.msg;
			// } catch (err) {}

			// 开发环境下，如果请求是 post,put,patch,则打印数据体，方便调试
			if (env) {
				// #ifdef H5
				console.groupCollapsed(
					"%c接收：%c" + baseUrl + url + " " + statusCode,
					"color: green",
					"color:orange"
				);
				console.log("返回数据：", res);
				console.groupEnd();
				// #endif
			}

			if (res.code != 0) {
				// token 过期 || 登录失效
				if (res.code == 1001) {
					uni.hideToast();
					uni.removeStorageSync("x-token"); //删除本地储存的Token
					removeToken(); //删除Token
					uni.showToast({
						title: res.msg || "未登录",
						duration: 1000,
						mask: false,
						icon: "none",
					});
			        setTimeout(() => {
			        	let routes = getCurrentPages(); // 获取当前打开过的页面路由数组
			        	let curRoute = routes[routes.length - 1].route;
			        	if (!~curRoute.indexOf("login/login")) {
				        	uni.navigateTo({
				    		url: "/pages/login/login",
				        	});
			        	}
		        	}, 1000);
					return Promise.reject(res);
				} else { // 业务处理失败，客户端把返回的失败原因显示给用户 
					uni.showToast({
						title: res.msg || "网络请求失败",
						duration: 1000,
						mask: false,
						icon: "none",
					});
					return Promise.reject(res);
				}

			} else {
				// 处理分页数据
				// if(res.data.next) {
				// 	res.nextPage = res.data.next;
				// }
				return res;
			}

		} else if (response.statusCode == 401) {

			uni.hideToast();
			uni.showToast({
				title: res.msg || "登录失效或在其他设备登录！",
				duration: 1000,
				mask: false,
				icon: "none",
			});
			removeToken();
			setTimeout(() => {
				let routes = getCurrentPages(); // 获取当前打开过的页面路由数组
				let curRoute = routes[routes.length - 1].route;
				if (!~curRoute.indexOf("login/login")) {
					uni.navigateTo({
						url: "/pages/login/login",
					});
				}
			}, 1000);

			return Promise.reject(res);
		} else if (response.statusCode == 500) {

			let msg = '获取数据失败！'
			if (env) {
				msg = "服务器错误！";
			}
			uni.hideToast();
			uni.showToast({
				title: msg,
				duration: 1000,
				mask: false,
				icon: "none",
			});

		} else {
			uni.hideToast();
			uni.showToast({
				title: "获取数据失败！",
				duration: 1000,
				mask: false,
				icon: "none",
			});
		}
	},
	(error) => {
		// 请求错误做点什么

		const {
			method,
			url,
			baseUrl
		} = error.config;

		let idx = reqList.indexOf(url);
		if (~idx) {
			reqList.splice(idx, 1);
		}

		// 开发环境下，如果请求是 post,put,patch,则打印数据体，方便调试
		if (env) {
			if (method === "post" || method === "put" || method === "patch") {
				// #ifdef H5
				console.groupCollapsed(
					"%c接收：%c" + baseUrl + url + " error",
					"color: green",
					"color:red"
				);
				console.log(error.errMsg);
				console.groupEnd();
				// #endif
			}
		}

		return error;
	}
);

// 加密
function encrypt(text) {
	var encryptData = http.config.encrypt.encryptByDES(text)
	// console.log('加密后--->',encryptData)
	return encryptData;
}

//解密
function decrypt(text) {
	var textData = text
	var parseData = ''
	if (text.data) {
		parseData = http.config.encrypt.decryptByDES(text.data)
		textData.data = JSON.parse(parseData)
		// console.log('解密后--->',textData)
	}
	return textData;
}

export default http;